﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using Persistencia_y_capa_de_negocio;
using System.Collections;

namespace clonegame
{
    public partial class formularioAdministrar : UserControl
    {
        /// <summary>
        /// Estado del formulario para saber si se perderán cambios
        /// </summary>
        private string estado = "editar";
        public string Estado
        {
            get { return estado; }
            set { estado = value; }
        }

        // Lista de administradores.
        private ArrayList lista;

        /// <summary>
        /// Instancia del formulario desde la cual accederemos a todos los datos, desde otros formularios.
        /// </summary>
        private static readonly formularioAdministrar instancia = new formularioAdministrar();
        public static formularioAdministrar Instancia
        {
            get { return instancia; }
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        public formularioAdministrar()
        {
            InitializeComponent();

            // Según el nivel del usuario logueado dispondrá de unas opciones u otras.
            if (formularioMaestro.Instancia.UsuarioLogueado.Nivel == 0)
            {
                this.cbNuevoNivel.Items.AddRange(new object[] {
                "Administrador",
                "Moderador",
                "Editor"});

                this.cbNivel.Items.AddRange(new object[] {
                "Administrador",
                "Moderador",
                "Editor"});

            }
            else
            {
                this.cbNuevoNivel.Items.AddRange(new object[] {
                "Moderador",
                "Editor"});

                this.cbNivel.Items.AddRange(new object[] {
                "Moderador",
                "Editor"});
            }

            // Por defecto seleccionamos la opción 0.
            cbNuevoNivel.SelectedIndex = 0;
            cbNivel.SelectedIndex = 0;
        }

        /// <summary>
        /// Al cargar el formulario se rellena la lista de administradores.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        public void formularioAdministrar_Load(object sender, EventArgs e)
        {
            // Rellenamos el DGV de administrar.
            RellenaDGV();
        }

        /// <summary>
        /// Rellena el DGV de administrar con la información de los administradores que hay en la base de datos.
        /// </summary>
        public void RellenaDGV()
        {
            // Número de filas del DGV.
            int numFilas = 0;

            // Obtenemos la lista de administradores.
            lista = CADAdmin.Instancia.getAdmins();

            // Limpiamos las filas que hubiera en el DGV anteriormente.
            dgvAdmin.Rows.Clear();

            // Indica si es el primer administrador de la lista.
            bool primero = true;
            foreach (ENAdmin ad in lista)
            {
                // Añadimos una nueva fila.
                dgvAdmin.Rows.Add(1);

                // Rellenamos el contenido de la fila.
                dgvAdmin.Rows[numFilas].Height = 25;
                dgvAdmin.Rows[numFilas].Cells[0].Value = ad.CuentaAd.ToString().Trim();
                switch (ad.Nivel.ToString().Trim())
                {
                    case "0":
                        {
                            dgvAdmin.Rows[numFilas].Cells[1].Value = "Root";
                            break;
                        }
                    case "1":
                        {
                            dgvAdmin.Rows[numFilas].Cells[1].Value = "Administrador";
                            break;
                        }
                    case "2":
                        {
                            dgvAdmin.Rows[numFilas].Cells[1].Value = "Moderador";
                            break;
                        }
                    case "3":
                        {
                            dgvAdmin.Rows[numFilas].Cells[1].Value = "Editor";
                            break;
                        }
                    default:
                        {
                            break;
                        }
                }

                if (primero == true)
                {
                    // Si es el primero cargamos su información en el panel de la derecha.
                    mostrarInformacion(0);
                    primero = false;
                }
                numFilas++;
            }
        }


        /// <summary>
        /// Solicita que se muestre la información del administrador de la fila seleccionada del DGV.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void dgvAdmin_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            // Comprobamos que el índice no sea negativo.
            if (e.RowIndex >= 0)
            {
                // Ocultamos el panel de nuevo admin.
                mostrarPanelAnadir(false);

                // Mostramos la información del administrador de la fila.
                mostrarInformacion(e.RowIndex);
            }
        }

        /// <summary>
        /// Actualiza el panel de la derecha con la información del administrador que se encuentra en la fila del DGV que recibe por 
        /// parámetro. Tiene en cuenta los privilegios del usuario logueado y del administrador seleccionado para permitir unas
        /// características u otras.
        /// </summary>
        /// <param name="fila"></param>
        void mostrarInformacion(int fila)
        {
            // Obtenemos la información del admin seleccionado.
            string nombreAdmin = dgvAdmin.Rows[fila].Cells[0].Value.ToString();
            ENAdmin ad = CADAdmin.Instancia.DevolverAdmin(nombreAdmin);

            // Comprobamos si el admin existe.
            if (ad != null)
            {
                // Cargamos la información del admin en el panel.
                tbNombre.Text = ad.CuentaAd.ToString().Trim();
                dtpFechaRegistro.Value = ad.FechaReg;

                
                // Para poder implementar estas funciones se necesita registrar en la BD quién es el creador.
                labelRecursosCreados.Text = CADRecurso.Instancia.getNumRecursosPorAdmin(tbNombre.Text).ToString();
                labelUnidadesCreadas.Text = CADUnidad.Instancia.getNumUnidadesPorAdmin(tbNombre.Text).ToString();
                labelEdificiosCreados.Text = CADEdificio.Instancia.getNumEdificiosPorAdmin(tbNombre.Text).ToString();
                labelNoticiasCreadas.Text = CADNoticia.Instancia.getNumNoticiasPorAdmin(tbNombre.Text).ToString();
                

                // Comprobamos los privilegios que tenemos sobre ese admin y bloqueamos las opciones no disponibles.
                if (formularioMaestro.Instancia.UsuarioLogueado.Nivel == 0)
                {
                    // Es el usuario root. Puede editar todo de todos excepto el nivel de si mismo.
                    if (ad.Nivel == 0) // Ha seleccionado el root.
                    {
                        gbInformacion.Enabled = true;
                        gbCambioNivel.Enabled = false;
                        gbContraseña.Enabled = true;
                        gbActividad.Enabled = true;

                        cbNivel.Items.Clear();
                        cbNivel.Items.AddRange(new object[] {
                        "Root",
                        "Administrador",
                        "Moderador",
                        "Editor"});
                        cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel);
                    }
                    else
                    {
                        gbInformacion.Enabled = true;
                        gbCambioNivel.Enabled = true;
                        gbContraseña.Enabled = true;
                        gbActividad.Enabled = true;

                        cbNivel.Items.Clear();
                        cbNivel.Items.AddRange(new object[] {
                        "Administrador",
                        "Moderador",
                        "Editor"});
                        cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel) -1;
                    }
                }
                else
                {
                    // Es un administrador. Puede editar todo de los moderadores y editores y a si mismo.
                    // Solo puede editar niveles a moderador y editor.
                    if (ad.Nivel == 0) // Ha seleccionado el root.
                    {
                        gbInformacion.Enabled = false;
                        gbCambioNivel.Enabled = false;
                        gbContraseña.Enabled = false;
                        gbActividad.Enabled = true;

                        cbNivel.Items.Clear();
                        cbNivel.Items.AddRange(new object[] {
                        "Root",
                        "Administrador",
                        "Moderador",
                        "Editor"});
                        cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel);
                    }
                    else if (ad.Nivel == 1) // Ha seleccionado un admin.
                    {
                        if (tbNombre.Text == formularioMaestro.Instancia.UsuarioLogueado.CuentaAd) // Es él mismo.
                        {
                            gbInformacion.Enabled = true;
                            gbCambioNivel.Enabled = false;
                            gbContraseña.Enabled = true;
                            gbActividad.Enabled = true;

                            cbNivel.Items.Clear();
                            cbNivel.Items.AddRange(new object[] {
                            "Administrador",
                            "Moderador",
                            "Editor"});
                            cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel) - 1;
                        }
                        else // Es otro administrador.
                        {
                            gbInformacion.Enabled = false;
                            gbCambioNivel.Enabled = false;
                            gbContraseña.Enabled = false;
                            gbActividad.Enabled = true;

                            cbNivel.Items.Clear();
                            cbNivel.Items.AddRange(new object[] {
                            "Administrador",
                            "Moderador",
                            "Editor"});
                            cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel) - 1;
                        }
                    }
                    else // Es un moderador o editor.
                    {
                        gbInformacion.Enabled = true;
                        gbCambioNivel.Enabled = true;
                        gbContraseña.Enabled = true;
                        gbActividad.Enabled = true;

                        cbNivel.Items.Clear();
                        cbNivel.Items.AddRange(new object[] {
                            "Moderador",
                            "Editor"});
                        cbNivel.SelectedIndex = Convert.ToInt32(ad.Nivel) - 2;
                    }
                }

                // Ocultamos el panel de nuevo administrador.
                gbNuevoAdministrador.Visible = false;
            }
            else
            {
                // Mostramos un error.
                MessageBox.Show("Error al seleccionar el administrador.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        /// <summary>
        /// Cambia la contraseña del administrador seleccionado.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void btCambiarContrasena_Click(object sender, EventArgs e)
        {
            // Limpiamos los errores mostrados.
            errorProvider.Clear();

            // Obtenemos la información.
            string contrasena = tbContrasena.Text;
            string repitaContrasena = tbRepitaContrasena.Text;
           

            // Comprobamos que la información es correcta.
            bool correcta = true;
            string patron = @"^\w{4}\w*$";

            if (contrasena == "")
            {
                string msjError = "Campo obligatorio";
                errorProvider.SetError(tbContrasena, msjError);
                tbContrasena.Focus();
                correcta = false;
            }
            else if (!Regex.Match(contrasena, patron).Success)
            {
                string msjError = "Solo puede estar compuesto por 4 o más caracteres.";
                errorProvider.SetError(tbContrasena, msjError);
                tbContrasena.Focus();
                correcta = false;
            }
            else if (contrasena != repitaContrasena)
            {
                string msjError = "Las contraseñas no coinciden.";
                errorProvider.SetError(tbContrasena, msjError);
                tbContrasena.Focus();
                correcta = false;
            }

            if (correcta == true)
            {
                // Limpiamos los errores mostrados.
                errorProvider.Clear();

                // Obtenemos el administrador.
                string nombreAdmin = tbNombre.Text;
                ENAdmin ad = CADAdmin.Instancia.DevolverAdmin(nombreAdmin);

                // Actualizamos la contraseña.
                CodMD5 codificar = new CodMD5();
                ad.ContrasenaAd = codificar.convertiraMD5(tbContrasena.Text);

                // Guardamos los cambios en la base de datos.
                if (CADAdmin.Instancia.ModificarAdmin(ad))
                {
                    // Registramos la actividad.
                    ENActividad act = new ENActividad();
                    act.Accion = "Modificación";
                    act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                    act.Descripcion = "Ha modificado la contraseña de " + nombreAdmin + ".";
                    act.Fecha = DateTime.Now.ToString();
                    CADActividad.Instancia.InsertarActividad(act);

                    // Mostramos un mensaje de confirmación.
                    MessageBox.Show("Contraseña cambiada.", "Éxito", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                }

                // Limpiamos los datos del formulario.
                tbContrasena.Text = "";
                tbRepitaContrasena.Text = "";
            }
        }

        /// <summary>
        /// Modifica el nivel del administrador seleccionado.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void btCambiarNivel_Click(object sender, EventArgs e)
        {
            // Obtenemos la información del administrador.
            string nombreAdmin = tbNombre.Text;
            ENAdmin ad = CADAdmin.Instancia.DevolverAdmin(nombreAdmin);

            // Obtenemos la información del nivel.
            int nivel = cbNivel.SelectedIndex + 1;
            if (formularioMaestro.Instancia.UsuarioLogueado.Nivel != 0) nivel++;

            // Modificamos el nivel del administrador seleccionado.
            ad.Nivel = nivel;

            // Actualizamos la información en la base de datos.
            if (CADAdmin.Instancia.ModificarAdmin(ad))
            {
                // Registramos la actividad.
                ENActividad act = new ENActividad();
                act.Accion = "Modificación";
                act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                act.Descripcion = "Ha modificado el nivel de " + nombreAdmin + ".";
                act.Fecha = DateTime.Now.ToString();
                CADActividad.Instancia.InsertarActividad(act);

                // Mostramos un mensaje de confirmación.
                MessageBox.Show("Nivel del usuario cambiado.", "Éxito", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                
                // Actualizamos el DGV.
                RellenaDGV();
            }
            else
            {
                // Ha ocurrido un error. Mostramos un mensaje.
                MessageBox.Show("Error al guardar los cambios en la base de datos.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }

        /// <summary>
        /// Elimina los administradores seleccionados en el DGV. Solicita una confirmación antes de eliminar los administradores seleccionados
        /// y comprueba que el usuario que realiza la eliminación tiene privilegios suficientes para eliminar. En caso de no tenerlos muestra
        /// un mensaje de error.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void btEliminar_Click(object sender, EventArgs e)
        {
            // Array list que contiene los administradores seleccionados.
            ArrayList seleccionados = new ArrayList();
            int seleccionadas = dgvAdmin.SelectedRows.Count;

            if (seleccionadas < 1)
            {
                // Mostramos un error si no ha seleccionado ningún administrador.
                MessageBox.Show("Debe seleccionar a alguien primero.", "Información", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button2);
            }
            else if (seleccionadas == 1)
            {
                // Obtenemos la información del administrador.
                string nombreAdmin = dgvAdmin.SelectedRows[0].Cells[0].Value.ToString();
                string nivelAdmin = dgvAdmin.SelectedRows[0].Cells[1].Value.ToString();

                // Solicitamos una confirmación antes de eliminar el administrador seleccionado.
                if (MessageBox.Show("¿Desea eliminar el " + nivelAdmin + " " + nombreAdmin + "?", "Información", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
                {
                    // Comprobamos si tiene permisos para eliminar ese administrador.
                    if (formularioMaestro.Instancia.UsuarioLogueado.Nivel == 0)
                    {
                        // Es el usuario root.
                        if (nivelAdmin != "Root")
                        {
                            // Puede borrarlo.
                            CADAdmin.Instancia.EliminaAdmin(dgvAdmin.SelectedRows[0].Cells[0].Value.ToString());
                            RellenaDGV();

                            ENActividad act = new ENActividad();
                            act.Accion = "Baja";
                            act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                            act.Descripcion = "Ha dado de baja el " + nivelAdmin + " " + nombreAdmin + ".";
                            act.Fecha = DateTime.Now.ToString();
                            CADActividad.Instancia.InsertarActividad(act);
                        }
                        else
                        {
                            // No puede borrar el root.
                            MessageBox.Show("El usuario root no puede ser eliminado.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                        }
                    }
                    else
                    {
                        // Es un administrador.
                        if (nivelAdmin != "Root" && nivelAdmin != "Administrador")
                        {
                            // Borramos el administrador.
                            CADAdmin.Instancia.EliminaAdmin(dgvAdmin.SelectedRows[0].Cells[0].Value.ToString());

                            // Actualizamos el DGV de administrar.
                            RellenaDGV();

                            // Registramos la actividad.
                            ENActividad act = new ENActividad();
                            act.Accion = "Baja";
                            act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                            act.Descripcion = "Ha dado de baja el " + nivelAdmin + " " + nombreAdmin + ".";
                            act.Fecha = DateTime.Now.ToString();
                            CADActividad.Instancia.InsertarActividad(act);
                        }
                        else
                        {
                            // No tiene permisos. Mostramos un mensaje de error.
                            MessageBox.Show("No tiene permisos para eliminar al " + nivelAdmin + " " + nombreAdmin + ".", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                        }
                    }
                }
            }
            else
            {
                // Solicitamos una confirmación antes de eliminar los administradores seleccionados.
                if (MessageBox.Show("¿Desea eliminar " + seleccionadas + " administradores?", "Información", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
                {
                    // Almacenamos el número real de administradores que se eliminan.
                    // Algunos de los administradores seleccionados podrían no borrarse si no tubiéramos privilegios suficientes para hacerlo.
                    int totalEliminados = 0;

                    foreach (DataGridViewRow r in dgvAdmin.SelectedRows)
                    {
                        // Obtenemos la información del administrador.
                        string nombreAdmin = r.Cells[0].Value.ToString();
                        string nivelAdmin = r.Cells[1].Value.ToString();

                        // Comprobamos si tiene permisos para eliminar ese administrador.
                        if (formularioMaestro.Instancia.UsuarioLogueado.Nivel == 0)
                        {
                            // Es el usuario root.
                            // Comprobamos que no esté intentando borrar el usuario root.
                            if (nivelAdmin != "Root")
                            {
                                // Borramos el administrador.
                                CADAdmin.Instancia.EliminaAdmin(r.Cells[0].Value.ToString());

                                // Incrementamos la cantidad de eliminados.
                                totalEliminados++;
                            }
                            else
                            {
                                // No puede borrar el root. Mostramos un mensaje de error.
                                MessageBox.Show("El usuario root no puede ser eliminado.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                            }
                        }
                        else
                        {
                            // Es un administrador.
                            // Comprobamos que no esté intentando borrar el usuario root u otro admin.
                            if (nivelAdmin != "Root" && nivelAdmin != "Administrador")
                            {
                                // Borramos el administrador.
                                CADAdmin.Instancia.EliminaAdmin(r.Cells[0].Value.ToString());

                                // Incrementamos la cantidad de eliminados.
                                totalEliminados++;
                            }
                            else
                            {
                                // No tiene permisos.
                                MessageBox.Show("No tiene permisos para eliminar al " + nivelAdmin + " " + nombreAdmin + ".", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                            }
                        }
                    }

                    // Actualizamos el DGV de administrar.
                    RellenaDGV();

                    // Comprobamos si finalmente se eliminó algún admin.
                    if (totalEliminados > 0)
                    {
                        // Registramos la actividad.
                        ENActividad act = new ENActividad();
                        act.Accion = "Baja";
                        act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                        act.Descripcion = "Ha dado de baja " + totalEliminados + " administradores.";
                        act.Fecha = DateTime.Now.ToString();
                        CADActividad.Instancia.InsertarActividad(act);
                    }
                }
            }

            // Actualizamos el DGV de bienvenida.
            formularioBienvenida.Instancia.actualizaResumen();
        }

        /// <summary>
        /// Muestra el panel para crear un nuevo administrador.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void btAnadir_Click(object sender, EventArgs e)
        {
            // Mostramos el panel de crear nuevo administrador.
            mostrarPanelAnadir(true);
        }

        /// <summary>
        /// Guarda el nuevo administrador. Limpia el panel, lo cierra y vuelve al modo editar.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void button1_Click(object sender, EventArgs e)
        {
            // Limpiamos los errores mostrados.
            errorProvider.Clear();
            
            // Obtenemos los datos del formulario.
            string nombre = tbNuevoNombre.Text;
            string contrasena = tbNuevaContrasena.Text;
            string repitaContrasena = tbRepitaNuevaContrasena.Text;
            int nivel = cbNuevoNivel.SelectedIndex + 1;
            if (formularioMaestro.Instancia.UsuarioLogueado.Nivel != 0) nivel++;
            

            // Comprobamos que los datos son correctos.
            bool correcto = true;
            string patron = @"^\w{4}\w*$";

            if (nombre == "")
            {
                string msjError = "Campo obligatorio";
                errorProvider.SetError(tbNuevoNombre, msjError);
                tbNuevoNombre.Focus();
                correcto = false;
            }
            else if (!Regex.Match(nombre, patron).Success)
            {
                string msjError = "Solo puede estar compuesto por 4 o más caracteres.";
                errorProvider.SetError(tbNuevoNombre, msjError);
                tbNuevoNombre.Focus();
                correcto = false;
            }

            if (contrasena == "")
            {
                string msjError = "Campo obligatorio";
                errorProvider.SetError(tbNuevaContrasena, msjError);
                tbNuevaContrasena.Focus();
                correcto = false;
            }
            else if (!Regex.Match(contrasena, patron).Success)
            {
                string msjError = "Solo puede estar compuesto por 4 o más caracteres.";
                errorProvider.SetError(tbNuevaContrasena, msjError);
                tbNuevaContrasena.Focus();
                correcto = false;
            }
            else if (contrasena != repitaContrasena)
            {
                string msjError = "Las contraseñas no coinciden.";
                errorProvider.SetError(tbNuevaContrasena, msjError);
                tbNuevaContrasena.Focus();
                correcto = false;
            }

            if (correcto == true)
            {
                // Limpiamos los errores mostrados.
                errorProvider.Clear();

                // Creamos el nuevo admin.
                ENAdmin admin = new ENAdmin();
                CodMD5 codificacion = new CodMD5();
                admin.CuentaAd = nombre;
                admin.ContrasenaAd = codificacion.convertiraMD5(contrasena);
                admin.Nivel = nivel;
                admin.FechaReg = DateTime.Now;

                // Insertamos el nuevo administrador en la BD.
                if (CADAdmin.Instancia.InsertarAdmin(admin))
                {
                    // Mostramos un mensaje de confirmación.
                    MessageBox.Show(cbNuevoNivel.Text + " creado correctamente", "Información", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    // Registramos la actividad.
                    ENActividad act = new ENActividad();
                    act.Accion = "Alta";
                    act.Responsable = formularioMaestro.Instancia.UsuarioLogueado.CuentaAd;
                    act.Descripcion = "Ha dado de alta un nuevo " + cbNuevoNivel.Text + ".";
                    act.Fecha = DateTime.Now.ToString();
                    CADActividad.Instancia.InsertarActividad(act);
                }
                else
                {
                    // Se ha producido un error al insertar.
                    // Este error podría ser porque ya existe.
                }

                // Actualizamos el DGV de bienvenida.
                formularioBienvenida.Instancia.actualizaResumen();

                // Actualizamos el DGV de administrar.
                formularioAdministrar.Instancia.RellenaDGV();

                // Limpiamos los datos del formulario de nuevo admin.
                tbNuevoNombre.Text = "";
                cbNuevoNivel.SelectedIndex = 0;
                tbNuevaContrasena.Text = "";
                tbRepitaNuevaContrasena.Text = "";
                
                // Ocultamos el panel de añdir.
                mostrarPanelAnadir(false);
            }
        }

        /// <summary>
        /// Cancela la creación de un nuevo administrador. Limpia el panel, lo cierra y vuelve al modo editar.
        /// </summary>
        /// <param name="sender">Objeto que envía la acción.</param>
        /// <param name="e">Argumentos.</param>
        private void button2_Click(object sender, EventArgs e)
        {
            // Limpiamos los datos del formulario de nuevo admin.
            tbNuevoNombre.Text = "";
            cbNuevoNivel.SelectedIndex = 0;
            tbNuevaContrasena.Text = "";
            tbRepitaNuevaContrasena.Text = "";
            gbNuevoAdministrador.Visible = false;
        }

        /// <summary>
        /// Oculta o muestra el panel de añadir.
        /// </summary>
        /// <param name="mostrar">True muestra, False oculta.</param>
        private void mostrarPanelAnadir(bool mostrar)
        {
            if (mostrar == true)
            {
                gbNuevoAdministrador.Visible = true;

                gbActividad.Visible = false;
                gbContraseña.Visible = false;
                gbCambioNivel.Visible = false;
                gbInformacion.Visible = false;
            }
            else
            {
                gbNuevoAdministrador.Visible = false;

                gbActividad.Visible = true;
                gbContraseña.Visible = true;
                gbCambioNivel.Visible = true;
                gbInformacion.Visible = true;
            }
        }

        private void dgvAdmin_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyValue == 46)
            {
                EventArgs ea = null;
                btEliminar_Click(sender, ea);
            }
        }

        private void formularioAdministrar_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyValue == 46)
            {
                EventArgs ea = null;
                btEliminar_Click(sender, ea);
            }
        }
    }
}
